/*
	已转移至  SkillFactory类
*/

package net.sf.odinms.client;

import java.util.ArrayList;
import java.util.List;

import net.sf.odinms.client.skills.*;
import net.sf.odinms.server.MapleStatEffect;
import net.sf.odinms.server.life.Element;

public class Skill implements ISkill {

    public int id;
    public List<MapleStatEffect> effects = new ArrayList<MapleStatEffect>();
    public Element element;
    public int animationTime;
    public boolean charge;
    public boolean isCommon;
    public int maxLevel;
    public int masterLevel;
    public boolean hasCharge;
    public static final int[] skills = new int[]{4330001, 4311003, 4321000, 4321002, 4321003, 4331002, 4331005, 4341004, 4341007, 4340010};

    public Skill(int id) {
        super();
        this.id = id;
    }

    @Override
    public int getId() {
        return id;
    }
    
    @Override
    public MapleStatEffect getEffect(int level) {
        return effects.get(level - 1);
    }

    @Override
    public int getMaxLevel() {
        return effects.size();
    }

    @Override
    public boolean canBeLearnedBy(MapleJob job) {
        int jid = job.getId();
        int skillForJob = id / 10000;
        if (jid / 100 != skillForJob / 100 && skillForJob / 100 != 0) { // wrong job
            return false;
        }
        if ((skillForJob / 10) % 10 > (jid / 10) % 10) { // wrong 2nd job
            return false;
        }
        if (skillForJob % 10 > jid % 10) { // wrong 3rd/4th job
            return false;
        }
        return true;
    }

    @Override
    public Element getElement() {
        return element;
    }

    @Override
    public int getAnimationTime() {
        return animationTime;
    }

    @Override
    public boolean isBeginnerSkill() {
        boolean output = false;
        String idString = String.valueOf(id);
        if (idString.length() == 4 || idString.length() == 1) {
            output = true;
        }
        return output;
    }

    @Override
    public boolean hasCharge() {
        return charge;
    }
      
    @Override
    public boolean getisCommon() {
        return isCommon;
    }
       
     @Override
     public boolean hasMastery() {
         if (this.masterLevel > 0) {
             return true;
         }
         int jobid = this.id / 10000;
         switch (jobid)
         {
             case 112:
                 int[] heskills = { 勇士.进阶斗气, 勇士.阿基里斯, 勇士.冒险岛勇士, 勇士.磁石, 勇士.稳如泰山, 勇士.突进, 勇士.勇猛劈砍, 勇士.葵花宝典, 勇士.勇士的意志 };
                 for (int gskill : heskills) {
                     if (this.id == gskill) {
                         return true;
                     }
                 }
                 break;
             case 122:
                 int[] paskills = { 骑士.阿基里斯, 骑士.守护之神, 骑士.万佛归一破, 骑士.冒险岛勇士, 骑士.稳如泰山, 骑士.神圣冲击, 骑士.突进, 骑士.连环环破, 骑士.圣域, 骑士.勇士的意志 };
                 for (int gskill : paskills) {
                     if (this.id == gskill) {
                         return true;
                     }
                 }
                 break;
             case 132:
                 int[] daskills = { 龙骑.阿基里斯, 龙骑.黑暗力量, 龙骑.灵魂治愈, 龙骑.灵魂祝福, 龙骑.冒险岛勇士, 龙骑.磁石, 龙骑.稳如泰山, 龙骑.突进, 龙骑.灵魂助力, 龙骑.勇士的意志 };
                 for (int gskill : daskills) {
                     if (this.id == gskill) {
                         return true;
                     }
                 }
                 break;
             case 212:
                 int[] fpskills = { 火毒.冒险岛勇士, 火毒.创世之破, 火毒.魔法反击, 火毒.火凤球, 火毒.终极无限, 火毒.火魔兽, 火毒.美杜莎之眼, 火毒.天降落星, 火毒.勇士的意志 };
                 for (int gskill : fpskills) {
                     if (this.id == gskill) {
                         return true;
                     }
                 }
                 break;
             case 222:
                 int[] ilskills = { 冰雷.冒险岛勇士, 冰雷.创世之破, 冰雷.魔法反击, 冰雷.冰凤球, 冰雷.终极无限, 冰雷.冰破魔兽, 冰雷.链环闪电, 冰雷.落霜冰破, 冰雷.勇士的意志 };
                 for (int gskill : ilskills) {
                     if (this.id == gskill) {
                         return true;
                     }
                 }
                 break;
             case 232:
                 int[] biskills = { 牧师.冒险岛勇士, 牧师.创世之破, 牧师.魔法反击, 牧师.强化圣龙, 牧师.终极无限, 牧师.圣灵之盾, 牧师.复活术, 牧师.光芒飞箭, 牧师.圣光普照, 牧师.勇士的意志 };
                 for (int gskill : biskills) {
                     if (this.id == gskill) {
                         return true;
                     }
                 }
                 break;
             case 312:
                 int[] boskills = { 弓手.神箭手, 弓手.冒险岛勇士, 弓手.火眼晶晶, 弓手.飞龙冲击波, 弓手.暴风箭雨, 弓手.火凤凰, 弓手.缓速箭, 弓手.集中精力, 弓手.勇士的意志 };
                 for (int gskill : boskills) {
                     if (this.id == gskill) {
                         return true;
                     }
                 }
                 break;
             case 322:
                 int[] crskills = { 弩手.飞龙冲击波, 弩手.神弩手, 弩手.冒险岛勇士, 弩手.穿透箭, 弩手.火眼晶晶, 弩手.冰凤凰, 弩手.刺眼箭, 弩手.一击要害箭, 弩手.冒险岛勇士 };
                 for (int gskill : crskills) {
                     if (this.id == gskill) {
                         return true;
                     }
                 }
                 break;
             case 412:
                 int[] inskills = { 标飞.假动作, 标飞.武器用毒液, 标飞.冒险岛勇士, 标飞.挑衅, 标飞.忍者伏击, 标飞.暗器伤人, 标飞.三连环光击破, 标飞.忍者冲击, 标飞.勇士的意志 };
                 for (int gskill : inskills) {
                     if (this.id == gskill) {
                         return true;
                     }
                 }
                 break;
             case 422:
                 int[] shskills = { 刀飞.假动作, 刀飞.武器用毒液, 刀飞.冒险岛勇士, 刀飞.暗杀, 刀飞.挑衅, 刀飞.忍者伏击, 刀飞.烟幕弹, 刀飞.一出双击, 刀飞.勇士的意志 };
                 for (int gskill : shskills) {
                     if (this.id == gskill) {
                         return true;
                     }
                 }
                 break;
             case 431:
                 if (this.id != 双刀.双刀风暴) break;
                 return true;
             case 432:
                 int du2skills[] = {双刀.龙卷风};
                 for (int gskill : du2skills) {
                     if (this.id == gskill) {
                         return true;
                     }
                 }
                 break;
             case 433:
                 int[] du3skills = { 双刀.镜像分身, 双刀.暗影飞跃斩 };
                 for (int gskill : du3skills) {
                     if (this.id == gskill) {
                         return true;
                     }
                 }
                 break;
             case 434:
                 int[] du4skills = { 双刀.冒险岛勇士, 双刀.武器用毒液, 双刀.终极斩, 双刀.怪物炸弹, 双刀.暴怒刀阵, /*4341005,地狱锁链调整到3转*/ 双刀.傀儡召唤, 双刀.荆棘, 双刀.勇士的意志, 双刀.幽灵一击/*093新增幽灵一击*/ };
                 for (int gskill : du4skills) {
                     if (this.id == gskill) {
                         return true;
                     }
                 }
                 break;
             case 512:
                 int[] buskills = { 拳手.冒险岛勇士, 拳手.潜龙出渊, 拳手.超能量, 拳手.超级变身, 拳手.金手指, 拳手.索命, 拳手.光速拳, 拳手.勇士的意志, 拳手.极速领域, 拳手.伺机待发 };
                 for (int gskill : buskills) {
                     if (this.id == gskill) {
                         return true;
                     }
                 }
                 break;
             case 522:
                 int[] coskills = { 枪手.冒险岛勇士, 枪手.属性强化, 枪手.超级章鱼炮台, 枪手.地毯式空袭, 枪手.金属风暴, 枪手.武装, 枪手.急速射, 枪手.重量炮击, 枪手.心灵控制, 枪手.勇士的意志, 枪手.导航辅助 };
                 for (int gskill : coskills) {
                     if (this.id == gskill) {
                         return true;
                     }
                 }
                 break;
             case 2112:
                 int[] ar4skills = { 战神.冒险岛勇士, 战神.攻击策略, 战神.战神之舞, 战神.战神的意志, 战神.防守策略, 战神.巨熊咆哮, 战神.钻石星辰, 战神.战神之盾, 战神.勇士的意志 };
                 for (int gskill : ar4skills) {
                     if (this.id == gskill) {
                         return true;
                     }
                 }
                 break;
             case 2217:
                 int[] ev9skills = { 龙神.冒险岛勇士, 龙神.魔法精通, 龙神.魔龙分身, 龙神.火焰轮, 龙神.勇士的意志 };
                 for (int gskill : ev9skills) {
                     if (this.id == gskill) {
                         return true;
                     }
                 }
                 break;
             case 2218:
                 int[] ev10skills = { 龙神.玛瑙的祝福, 龙神.熊熊烈火, 龙神.黑暗迷雾, 龙神.灵魂之石, 龙神.玛瑙的意志 };
                 for (int gskill : ev10skills) {
                     if (this.id == gskill) {
                         return true;
                     }
                 }
                 break;
             case 3212:
                 int[] hlskills = { 战法.进阶黑暗灵气, 战法.进阶黄色灵气, 战法.飓风, 战法.黑暗创世, 战法.稳如泰山, 战法.避难所, 战法.冒险岛勇士, 战法.勇士的意志, 战法.致命冲击 };
                 for (int gskill : hlskills) {
                     if (this.id == gskill) {
                         return true;
                     }
                 }
                 break;
             case 3312:
                 int bnskills[] ={弩骑.神弩手, 弩骑.闪光箭雨, 弩骑.音速震波, 弩骑.火眼晶晶, 弩骑.冒险岛勇士, 弩骑.神经毒气, 弩骑.暴走形态, 弩骑.奥义箭乱舞, 弩骑.勇士的意志 };
                 for (int gskill : bnskills) {
                     if (this.id == gskill) {
                         return true;
                     }
                 }
                 break;
             case 3512:
                 int jjskills[] = {机械师.终极机甲, 机械师.机器人精通, 机械师.战争机器_泰坦, 机械师.金属机甲_导弹战车, 机械师.卫星防护, 机械师.冒险岛勇士, 机械师.勇士的意志, 机械师.机器人工厂_RM1, 机械师.放大器_AF_11, 机械师.激光爆破};
                 for (int gskill : jjskills) {
                     if (this.id == gskill) {
                         return true;
                     }
                 }
         }
         return false;
     }
     
     /*
     @Override
     public int getMasterLevel() {
         return masterLevel;
     }
     */
/*     public boolean isFourthJob() {
        if (id / 10000 >= 2212 && id / 10000 < 3000) { //evan skill
            return ((id / 10000) % 10) >= 7;
        }
        if (id / 10000 >= 430 && id / 10000 <= 434) { //db skill
            return ((id / 10000) % 10) == 4 || isMasterSkill(id);
        }
        return ((id / 10000) % 10) == 2;
    }*/

    public static final boolean isMasterSkill(final int skill) {
        for (int i : skills) {
            if (i == skill) {
                return true;
            }
        }
        return false;
    }
     
 public boolean isFourthJob() {
        switch (id) {
            case 勇士.战斗精通://战斗精通
            case 骑士.祝福护甲://祝福护甲
            case 龙骑.灵魂复仇://灵魂复仇
            case 火毒.魔力精通://魔力精通
            case 冰雷.魔力精通://魔力精通
            case 牧师.魔力精通://魔力精通
            case 弓手.射术精修://射术精修
            case 弩手.射术精修://射术精修
            case 标飞.娴熟飞镖术://娴熟飞镖术
            case 刀飞.贪婪://贪婪
            case 双刀.闪光弹://闪光弹
            case 双刀.暗影二段跳://暗影二段跳
            case 双刀.悬浮地刺://悬浮地刺
            case 拳手.反制攻击://反制攻击
            case 枪手.反制攻击://反制攻击
            case 战神.迅捷移动://迅捷移动
            case 龙神.冰点寒气://冰点寒气
            case 龙神.自然力重置://自然力重置
            case 龙神.咒语精通://咒语精通
            case 战法.活力激化://活力激化
            case 弩骑.野性本能://野性本能
                return false;
        }

        return ((id / 10000) % 10) == 2;
    }

    @Override
    public boolean isEvanFourthJob() {
        boolean flage = false;
        switch (id) {
            case 龙神.冒险岛勇士:
            case 龙神.魔法精通:
            case 龙神.魔龙分身:
            case 龙神.火焰轮:
            case 龙神.勇士的意志:
            case 龙神.玛瑙的祝福:
            case 龙神.熊熊烈火:
            case 龙神.黑暗迷雾:
            case 龙神.灵魂之石:
                flage = true;
                break;
        }
        return flage;
    }

    @Override
    public boolean isDualFourthJob() {
        boolean flage = false;
        switch (id) {
            case 双刀.双刀风暴:
            case 双刀.龙卷风:
            case 双刀.镜像分身:
            case 双刀.暗影飞跃斩:
            case 双刀.冒险岛勇士:
            case 双刀.武器用毒液:
            case 双刀.终极斩:
            case 双刀.怪物炸弹:
            case 双刀.暴怒刀阵:
            case 双刀.闪光弹:
            case 双刀.地狱锁链:
            case 双刀.血雨腥风:
            case 双刀.锋利:
            case 双刀.傀儡召唤:
            case 双刀.荆棘:
            case 双刀.勇士的意志:
            case 双刀.幽灵一击://幽灵一击
                flage = true;
                break;
        }
        return flage;
    }

    @Override
    public boolean isBigBangFourthJob() {
        boolean flage = false;
        switch (id) {
            case 战法.进阶黑暗灵气://进阶黑暗灵气
            case 战法.进阶黄色灵气://进阶黄色灵气
            case 战法.飓风://飓风
            case 战法.黑暗创世://黑暗创世
            case 战法.稳如泰山://稳如泰山
            case 战法.避难所://避难所
            case 战法.冒险岛勇士://冒险岛勇士
            case 战法.勇士的意志:

            case 弩骑.神弩手://神弩手
            case 弩骑.闪光箭雨://闪光箭雨
            case 弩骑.音速震波://音速震波
            case 弩骑.火眼晶晶://火眼晶晶
            case 弩骑.冒险岛勇士://冒险岛勇士
            case 弩骑.神经毒气://神经毒气
            case 弩骑.暴走形态://暴走形态
            case 弩骑.奥义箭乱舞://奥义箭乱舞
            case 弩骑.勇士的意志:

            case 机械师.终极机甲: //终极机甲
            case 机械师.机器人精通://机器人精通
            case 机械师.战争机器_泰坦://战争机器：泰坦
            case 机械师.金属机甲_导弹战车://金属机甲：导弹战车
            case 机械师.卫星防护://卫星防护
            case 机械师.冒险岛勇士://冒险岛勇士
            case 机械师.机器人工厂_RM1://机器人工厂：RM1
            case 机械师.放大器_AF_11://放大器：AF-11
            case 机械师.激光爆破://激光爆破
            case 机械师.勇士的意志://勇士的意志:
                flage = true;
                break;
        }
        return flage;
    }

}